PlutoBoard

Work Distribution

Group Members

Nicole Lin, ECE '21

nl392@cornell.edu

Designed the hardware and wrote GPIO code. Split soldering and wire stripping duties. Split testing and debugging during assembly.

Joseph Benjamin, MAE '20

jkb237@cornell.edu

Designed and wrote UI code, designed file structure. Split soldering and wire stripping duties. Split testing and debugging during assembly.

Code Appendix

wall_ui.py

## nl392_jkb237
## final project
## wall_ui.py

###################################################################################################
## SYSTEM SETUP

import RPi.GPIO as GPIO
import time
import sys
import pygame
import os
import os.path
import shutil
import random
from shutil import copyfile
from os import path
from pygame.locals import *

os.putenv('SDL_VIDEODRIVER','fbcon')
os.putenv('SDL_FBDEV','/dev/fb1')
os.putenv('SDL_MOUSEDRV','TSLIB')
os.putenv('SDL_MOUSEDEV','/dev/input/touchscreen')

# initialize pygame and hide mouse on screen
pygame.init()
pygame.mouse.set_visible(False)

# quit button setup
GPIO.setmode(GPIO.BCM) # set pin numbering scheme to that of Broadcom chip
GPIO.setup(27, GPIO.IN, pull_up_down=GPIO.PUD_UP)
def GPIO27_callback(channel):
    quit()
GPIO.add_event_detect(27, GPIO.FALLING, callback=GPIO27_callback)

# screen resolution
size = w,h = 320,240
screen = pygame.display.set_mode(size)

###################################################################################################
## INITIALIZE VARIABLES 

# RGB values
WHT = 255,255,255
BLK = 0,0,0
RED = 128,0,0
GRN = 0,128,0
BLU = 0,155,255
GRY = 128,128,128
v01 = 0,100,255
v24 = 0,255,50
v56 = 255,200,0
v7 = 255,25,0
diffColors = [v01,v24,v56,v7]

# font sizes
med_h = 35
sm_h = 25
lg_h = 50
med_font = pygame.font.Font(None,med_h)
sm_font = pygame.font.Font(None,sm_h)
lg_font = pygame.font.Font(None,lg_h)

# initial menu states and initialize variables
running = True 
menu = 'main' # used to navigate menus
user = 0 # variable which indexes through list of users, indicating current users
users = [] # list of users
letter = '' # user input variable for letter entry menus
route = 0 # variable which indexes through list of user routes, indicating current route
current_route = 0 # route currently displayed on the board, similar to route variable
nRoute = '' # concatenated letters of new route string
nUser = '' # concatenated letters of new user string
nRouteStr = [] # letters of new route string
nUserStr = [] # letters of new user string
confirmOrigin = '' # used to indicate which menu the user came from before the current confirmation menu
difficulty_selected = False # flag indicating if user has selected desired random route difficulty
randomRoute = False # flag indicating if user is on a routedisplay for a freshly created random route
stackChance = .3 # probability that two holds will be permitted to be directly above and below one another
diffs = ['V0-1','V2-4','V5-6','V7+'] # list of difficulties
diffListY = 145
diffPos = [(45,diffListY),(122,diffListY),(198,diffListY),(275,diffListY)]
difficulty = 4

###################################################################################################
## HELPER FUNCTIONS

# helper function to blit text to screen with specific alignment, color, size, and position
def blit_button(text,font,color,alignment,pos):
    text_surface = font.render(text,True,color)
    if alignment is 'midleft':
        rect = text_surface.get_rect(midleft=pos)
    elif alignment is 'midright':
        rect = text_surface.get_rect(midright=pos)
    elif alignment is 'midtop':
        rect = text_surface.get_rect(midtop=pos)
    elif alignment is 'topleft':
        rect = text_surface.get_rect(topleft=pos)
    elif alignment is 'bottomright':
        rect = text_surface.get_rect(bottomright=pos)
    elif alignment is 'bottomleft':
        rect = text_surface.get_rect(bottomleft=pos)
    elif alignment is 'topright':
        rect = text_surface.get_rect(topright=pos)
    else:
        rect = text_surface.get_rect(center=pos)
    screen.blit(text_surface,rect)


# helper function to update user list and users.txt
def update_userstxt():
    userfile = open('users.txt','w') # open blank file
    for userline in users: # write new line for each user
        userfile.writelines(userline+'\n')
    userfile.close() # close file

# helper function to update padding and spacing values
def update_padNspace():
    global spacing
    if len(users)<=3:
        spacing = 60
    elif len(users)<=5:
        spacing = 40
    global padding
    padding = (240-len(users)*(spacing))/2

# function to generate random route
def randRoute(diff,routename):
    column = [0,0,0,0,0,0,0,0]
    newRoute = []
    for row in range(8):
        if row is 0:
            # make bottom row (2 holds)
            holds = 2 # number of holds possible in a certain row
            miss = .1 # probability that any one hold will not be "generated" as "on"
            botRow = True
        elif row is 7:
            # make top row (1 hold)
            holds = 1
            miss = 0
        else:
            if diff is 0:
                holds = 2
                miss = .15
            elif diff is 1:
                holds = 2
                miss = .3
            elif diff is 2:
                holds = 1
                miss = .15
            elif diff is 3:
                holds = 1
                miss = .3
        # make a random row
        if not botRow: # dont store the previous row for the bottom row (there isn't one)
            prevRow = newRow
        else:
            prevRow = [0,0,0,0,0] # assume no holds on the row previous to the bottom row
        newRow = [0,0,0,0,0]
        holdInRow = False # start with a blank row
        if sum(prevRow) is 0: # keep track of whether or not the previous row had no holds
            aboveBlank = True 
        else:
            aboveBlank = False
        locSearch = True
        for x in range(holds):
            while locSearch is True:
                location = int(round(random.random()*4)) # propose a possible new location (column coordiante) for a hold
                if prevRow[location] is 1: # if the previous row had a hold in the same column, keep looking, but do a roll for a chance to have "stacked" holds
                    locSearch = True
                    stackRoll = random.random()
                    if stackChance > stackRoll: # roll for chance to "stack" holds
                        locSearch = False
                elif prevRow[location] is 0: # if the previous row did not have a hold in the same column, we have found the location for the new holds
                    locSearch = False
            roll = random.random() # random roll 
            # add a hold at the location from the search if the roll "hits", or if the previous row was blank and this is the last possible hold in this row unless diff > 1
            if miss < roll or ((aboveBlank is True) and (holdInRow is False and x is holds-1) and diff <=1):
                newRow[location] = 1
                holdInRow = True
        newRoute.append(newRow)
    routefile = open(users[user]+'/routes/'+routename+'.txt','w') # open blank file
    for columnindex in range(5): # current row
        for rowindex in range(8): # current row
            column[rowindex] = str(newRoute[rowindex][columnindex]) # grab hold value from current row for current column
        routefile.writelines(''.join(column)+'\n') # store column as a line
    routefile.close() # close file
    routefile = open(users[user]+'/routes/'+routename+'.txt','a') # open populated file
    routefile.write('diff: \n'+str(diff)+'\n') # append on the difficulty tags
    routefile.close() # close file

# helper function to show blank board
def blank_board():
    copyfile('blank_board.txt','current_board.txt')

# helper function to load current route to current board
def load_route(user,route):
    copyfile(users[user]+'/routes/'+userRoutes[route]+'.txt','current_board.txt') # loads current route into current board

# check the difficulty level of a route
def check_diff(user,route):
    routefile = open(users[user]+'/routes/'+userRoutes[route]+'.txt','r') # open populated file
    for lastline in routefile: # iterates through all the lines
        pass
    return int(lastline) # lastline ends up being the contents of the final line of the file (str of difficulty)
    routefile.close()

# change the difficulty level of the displayed route
def change_diff(newdiff):
    routelines = open('current_board.txt','r').readlines() # gets each line of the route file, storing in a list
    routelines[-1] = str(newdiff)+'\n' # changes difficulty tag to the new difficulty
    open('current_board.txt','w').writelines(routelines) # rewrites all the lines to the currentboard with updated difficulty

# helper function to load routes for specified user
def load_userRoutes(usernum):
    global userRoutes
    global userRouteCount
    userRoutes = os.listdir(users[usernum]+'/routes') # makes a list of all the route files in the user's directory
    userRouteCount = len(userRoutes) # counts how many users there are, for the padding and spacing of the user menu
    for i in range(userRouteCount): 
        userRoutes[i] = os.path.splitext(userRoutes[i])[0] # removes the .txt from each route name
    print(userRoutes)

###################################################################################################
## MAIN LOOP SETUP

# load users
userfile = open('users.txt','r')
usercount = 0

while True:
    users.append(userfile.readline().rstrip('\n')) # add line contents to users list, minus newline
    if not users[usercount]: # if the line was empty, delete the user that was created and exit
        users.pop(len(users)-1)
        break
    elif not path.exists(users[usercount]):
        os.mkdir(users[usercount])
    if not path.exists(users[usercount]+'/routes'):
        os.mkdir(users[usercount]+'/routes')
    usercount +=1

userfile.close() # be sure to close file

update_padNspace()

###################################################################################################
## MAIN LOOP

while running:
    if len(users)<1:
        menu = '+user'
                   
    # get mouseclick and sort it into a command based on screen location
    for event in pygame.event.get():
        if event.type is MOUSEBUTTONUP:
            pos = pygame.mouse.get_pos()
            x,y = pos
            print('location: x:'+str(x)+' y:'+str(y))
            if menu is 'main': # select or create user
                if x>130 and x<190:
                    if y>65 and y<115: # select
                        menu = 'user'
                    elif y>125 and y<175: # create
                        if len(users)<5: # maximum 5 users
                            del nUserStr[:] # clear new user name before going to menu
                            menu = '+user'
                        else:
                            pass
            elif menu is 'user': # list of users
                if x>70 and x<250:
                    if y>padding and y<(padding+lg_h): # if clicked on first user's name
                        user = 0 # used to track which user is currently being accessed
                        load_userRoutes(user) # updates list of routes which belong to the user
                        menu = 'actions'
                    if len(users)>1:
                        if y>padding+spacing and y<(padding+spacing+lg_h):  
                            user = 1
                            load_userRoutes(user) 
                            menu = 'actions'
                    if len(users)>2:
                        if y>padding+2*spacing and y<(padding+2*spacing+lg_h):
                            user = 2
                            load_userRoutes(user)
                            menu = 'actions'
                    if len(users)>3:
                        if y>padding+3*spacing and y<(padding+3*spacing+lg_h):
                            user = 3
                            load_userRoutes(user)
                            menu = 'actions'
                    if len(users)>4:
                        if y>padding+4*spacing and y<(padding+4*spacing+lg_h):
                            user = 4
                            load_userRoutes(user)
                            menu = 'actions'
                if x>5 and x<90 and y>195 and y<225:
                    menu = 'main'
            elif menu is '+user': # keyboard to enter new user
                if 850: # back button
                    menu = 'main'
                elif x>260 and x<310 and y>195 and y<225: # backspace button
                    if len(nUserStr)>0:
                        nUserStr.pop(len(nUserStr)-1)
                    else:
                        pass
                elif 120130 and x<190:
                    if 505 and x<90 and y>195 and y<225: # back button
                    menu = 'user'
                elif 210195 and y<225: # back button
                    menu = 'actions'
                elif 050:
                    if 50 0:
                        route = 0 # used to track which route is currently being accessed
                        menu = 'routedisplay'
                        load_route(user,route) # copies the route we selected to the current_board.txt
                        difficulty = int(check_diff(user,route)) # updates the difficulty for display purposes
                    elif 80 1:
                        route = 1
                        menu = 'routedisplay'
                        load_route(user,route)
                        difficulty = int(check_diff(user,route))
                    elif 110 2:
                        route = 2
                        menu = 'routedisplay'
                        load_route(user,route)
                        difficulty = int(check_diff(user,route))
                    elif 140 3:
                        route = 3
                        menu = 'routedisplay'
                        load_route(user,route)
                        difficulty = int(check_diff(user,route))
                elif 160 4:
                        route = 4
                        menu = 'routedisplay'
                        load_route(user,route)
                        difficulty = check_diff(user,route)
                    elif 50 5:
                        route = 5
                        menu = 'routedisplay'
                        load_route(user,route)
                        difficulty = check_diff(user,route)
                    elif 80 6:
                        route = 6
                        menu = 'routedisplay'
                        load_route(user,route)
                        difficulty = check_diff(user,route)
                    elif 110 7:
                        route = 7
                        menu = 'routedisplay'
                        load_route(user,route)
                        difficulty = check_diff(user,route)
                    elif 140 8:
                        route = 8
                        menu = 'routedisplay'
                        load_route(user,route)
                        difficulty = check_diff(user,route)
                else:
                    pass
            elif menu is '+route' or menu is 'saveas': # keyboard to enter new route
                if 85260 and x<310 and y>195 and y<225: # backspace button
                    if len(nRouteStr)>0:
                        nRouteStr.pop(len(nRouteStr)-1)
                    else:
                        pass
                elif 1205 and x<90 and y>195 and y<225: # back button
                    if randomRoute is True:
                        randomRoute = False
                    menu = 'routes'
                elif 2105 and x<90 and y>195 and y<225: # back button
                    menu = 'actions'
            elif menu is 'confirm': # confirmation menu
                if 505 and x<90 and y>195 and y<225: # back button
                    menu = 'routes'
                elif 1000:
#        print('user name: ' + users[user])

    ################################################################################################
    ## BLIT NEW DISPLAY

    #blank display
    screen.fill(BLK)
    nRoute = ''.join(nRouteStr)
    nUser = ''.join(nUserStr)
    
    if menu is 'main':
        blit_button('select user',lg_font,WHT,'center',(160,90)) # select user button
        if len(users)<5: # only blit white create user button if <5 users
            blit_button('create user',lg_font,WHT,'center',(160,150))
        else: # otherwise gray out create user button
            blit_button('create user',lg_font,GRY,'center',(160,150))
    elif menu is 'user':
        i = 0
        for username in users: # blit each user name according to locations calculated by update_padNspace()
            blit_button(username,lg_font,WHT,'midtop',(160,padding+spacing*i))
            i+=1
        blit_button('back',med_font,WHT,'midleft',(20,220))
    elif menu is '+user':
        if nUser in users:
            blit_button('user exists',sm_font,RED,'midtop',(160,10))
            blit_button('ENTER',med_font,GRY,'center',(160,220)) # enter button
        else:
            blit_button('enter new user name',sm_font,WHT,'midtop',(160,10)) # prompt for new name
            blit_button('ENTER',med_font,WHT,'center',(160,220)) # enter button
        blit_button('Q  W  E  R  T  Y  U  I  O  P',med_font,WHT,'center',(160,100)) # keyboard row 1
        blit_button('A  S  D  F  G  H  J  K  L',med_font,WHT,'center',(160,140)) # keyboard row 2
        blit_button('Z  X  C  V  B  N  M',med_font,WHT,'center',(160,180)) #keyboard row 3
        if len(users)>0:
            blit_button('back',med_font,WHT,'midleft',(20,220)) # back button, only allowed if there is a profile in existence
        else:
            blit_button('back',med_font,GRY,'midleft',(20,220)) # back button, only displayed if there is a profile in existence
        pygame.draw.line(screen,WHT,(300,220),(270,220),3) # arrow
        pygame.draw.line(screen,WHT,(270,220),(278,210),3) # arrow
        pygame.draw.line(screen,WHT,(270,220),(278,230),3) # arrow
        blit_button(''.join(nUserStr),med_font,WHT,'center',(160,55)) # current user name input
    elif menu is 'actions':
        blit_button(users[user],sm_font,WHT,'midtop',(160,10)) # show user's name at the top
        blit_button('select route',lg_font,WHT,'center',(160,75)) # select route button
        blit_button('change incline',lg_font,WHT,'center',(160,145)) # change incline button
        blit_button('delete user',sm_font,WHT,'bottomright',(310,230)) # delete the user's profile
        blit_button('back',med_font,WHT,'midleft',(20,220)) # back button
    elif menu is 'routes':
        j = 0
        for routename in userRoutes: # list routes
            if j<4:
                blit_button(routename,sm_font,WHT,'topleft',(20,50+j*30)) # left column
            if 4<=j<8:
                blit_button(routename,sm_font,WHT,'topright',(300,50+(j-4)*30)) # right column
            j+=1
        blit_button('+route',med_font,BLU,'topleft',(5,5)) # add new route button
        blit_button('random',med_font,BLU,'topright',(315,5)) # add random route button
        blit_button('back',med_font,WHT,'midleft',(20,220)) # back button
    elif menu is 'routedisplay':
        blit_button(userRoutes[route],lg_font,GRN,'center',(160,100)) # route name
        blit_button('save as',med_font,BLU,'topright',(310,10)) # save as button
        blit_button('save',med_font,BLU,'topleft',(5,5)) # add new route button
        blit_button('delete route',sm_font,WHT,'bottomright',(310,230)) # delete the route
        blit_button('back',med_font,WHT,'midleft',(20,220)) # back button
        if difficulty<4:
            blit_button(diffs[difficulty],med_font,diffColors[difficulty],'center',diffPos[difficulty])
        else:
            for diffButton in range(4):
                blit_button(diffs[diffButton],med_font,diffColors[diffButton],'center',diffPos[diffButton])
    elif menu is '+route' or menu is 'saveas':
        if nRoute in userRoutes: # if new route name already exists
            blit_button('route exists',sm_font,RED,'midtop',(160,10))
            blit_button('ENTER',med_font,GRY,'center',(160,220)) # enter button
        else:
            blit_button('enter new route name',sm_font,WHT,'midtop',(160,10)) # prompt for new name
            blit_button('ENTER',med_font,WHT,'center',(160,220)) # enter button
        blit_button('Q  W  E  R  T  Y  U  I  O  P',med_font,WHT,'center',(160,100)) # keyboard row 1
        blit_button('A  S  D  F  G  H  J  K  L',med_font,WHT,'center',(160,140)) # keyboard row 2
        blit_button('Z  X  C  V  B  N  M',med_font,WHT,'center',(160,180)) #keyboard row 3
        blit_button('back',med_font,WHT,'midleft',(20,220)) # back button, only allowed if there is a profile in existence
        pygame.draw.line(screen,WHT,(300,220),(270,220),3) # arrow
        pygame.draw.line(screen,WHT,(270,220),(278,210),3) # arrow
        pygame.draw.line(screen,WHT,(270,220),(278,230),3) # arrow
        blit_button(''.join(nRouteStr),med_font,WHT,'center',(160,55)) # current route name input
    elif menu is 'incline':
        blit_button('INCLINE',lg_font,WHT,'center',(160,120))
        blit_button('back',med_font,WHT,'midleft',(20,220)) # back button
    elif menu is 'confirm':
        blit_button('are you sure?',lg_font,WHT,'center',(160,40))
        blit_button('yes',lg_font,WHT,'midleft',(50,140))
        blit_button('cancel',lg_font,WHT,'midright',(270,140))
    elif menu is 'random':
        blit_button('select difficulty',sm_font,WHT,'midtop',(160,10))
        blit_button('v0-v1',med_font,v01,'center',(160,60))
        blit_button('v2-v4',med_font,v24,'center',(160,100))
        blit_button('v5-v6',med_font,v56,'center',(160,140))
        blit_button('v7+',med_font,v7,'center',(160,180))
        blit_button('back',med_font,WHT,'midleft',(20,220)) # back button

    #display new objects
    pygame.display.flip()

GPIO.cleanup()

              

gpio.py

## nl392 jkb237
## final project
## gpio.py

###################################################################################################
## SYSTEM SETUP

import RPi.GPIO as GPIO
import shutil
import time
import os
import subprocess

# enable piTFT
#os.putenv('SDL_VIDEODRIVER','fbcon')
#os.putenv('SDL_FBDEV','/dev/fb1')
#os.putenv('SDL_MOUSEDRV','TSLIB')
#os.putenv('SDL_MOUSEDEV','/dev/input/touchscreen')

# some notes
# the BCM2837 clock speed is 1.2GHz, the shift registers max CLK speed at 5V is approx 25MHz

# shift register pin numbers
SHIFT_MASTER_RECLEAR_PIN = 14 
SHIFT_OUTPUT_EN_PIN = 16
SHIFT_DATA_PIN = 20
SHIFT_LATCH_PIN = 12
SHIFT_CLK_PIN = 15

# MUX pin numbers
MUX_SEL_A_PIN = 13
MUX_SEL_B_PIN = 19
MUX_SEL_C_PIN = 26
MUX_DATA0_PIN = 4
MUX_DATA1_PIN = 17
MUX_DATA2_PIN = 22
MUX_DATA3_PIN = 5
MUX_DATA4_PIN = 6

# GPIO setup
GPIO.setmode(GPIO.BCM)
GPIO.setup(SHIFT_MASTER_RECLEAR_PIN, GPIO.OUT, initial = 1) # active low signal
GPIO.setup(SHIFT_OUTPUT_EN_PIN, GPIO.OUT, initial = 0) # active low signal
GPIO.setup(SHIFT_DATA_PIN, GPIO.OUT, initial = 0)
GPIO.setup(SHIFT_LATCH_PIN, GPIO.OUT, initial = 0) 
GPIO.setup(SHIFT_CLK_PIN, GPIO.OUT, initial = 0)
# look into using PWM pins for control CLK
GPIO.setup(MUX_SEL_A_PIN, GPIO.OUT, initial = 0)
GPIO.setup(MUX_SEL_B_PIN, GPIO.OUT, initial = 0)
GPIO.setup(MUX_SEL_C_PIN, GPIO.OUT, initial = 0)
GPIO.setup(MUX_DATA0_PIN, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(MUX_DATA1_PIN, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(MUX_DATA2_PIN, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(MUX_DATA3_PIN, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(MUX_DATA4_PIN, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

# bailout
GPIO.setup(27, GPIO.IN, pull_up_down=GPIO.PUD_UP)
def GPIO27_callback(channel):
#    os.system('./quit')
    GPIO.output(SHIFT_OUTPUT_EN_PIN, 1)
    GPIO.output(SHIFT_MASTER_RECLEAR_PIN, 0)
    time.sleep(.5)
    GPIO.cleanup()
    quit()
GPIO.add_event_detect(27, GPIO.FALLING, callback=GPIO27_callback)

###################################################################################################
## INITIALIZE VARIABLES

# buttons, 1 for pressed, 0 for unpressed
# if pressed, corresponding LED toggles.

# LEDs
nLEDs = 40
led = []
for i in range(nLEDs):
    led.append(0)

# this doesn't need to be multidimensional, in fact it will make it easier for serial data to just
# have one stream

# flags
something_changed = False
periodic_refresh = False
timer = time.time()
debounce_timer = time.time()

###################################################################################################
## HELPER FUNCTIONS

def button_refresh():
#    print('button refresh started')
    global something_changed
    global debounce_timer

    debounce_time = 0.15

    for i in range (8):
        # set control signals
        if ((i & 0b001)==1): GPIO.output(MUX_SEL_A_PIN, 1)
        else: GPIO.output(MUX_SEL_A_PIN, 0)
        if ((i & 0b010)==2): GPIO.output(MUX_SEL_B_PIN, 1)
        else: GPIO.output(MUX_SEL_B_PIN, 0)
        if ((i & 0b100)==4): GPIO.output(MUX_SEL_C_PIN, 1)
        else: GPIO.output(MUX_SEL_C_PIN, 0)
        
        if time.time() - debounce_timer > debounce_time:
            # check data signals
            # mux1 -> btn 0-7
            if (GPIO.input(MUX_DATA0_PIN) == 1): 
                print('button detected mux0')
                led[i] = 1 if led[i] == 0 else 0
                something_changed = True
            # mux2 -> btn 8-15
            if (GPIO.input(MUX_DATA1_PIN) == 1): 
                print('button detected mux1')
                led[i + 8] = 1 if led[i + 8] == 0 else 0
                something_changed = True
            # mux3 -> btn 16-23
            if (GPIO.input(MUX_DATA2_PIN) == 1): 
                print('button detected mux2')
                led[i + 16] = 1 if led[i + 16] == 0 else 0
                something_changed = True
            # mux4 -> btn 24-31
            if (GPIO.input(MUX_DATA3_PIN) == 1): 
                print('button detected mux3')
                led[i + 24] = 1 if led[i + 24] == 0 else 0
                something_changed = True
            # mux5 -> btn 32-39
            if (GPIO.input(MUX_DATA4_PIN) == 1): 
                print('button detected mux4')
                led[i + 32] = 1 if led[i + 32] == 0 else 0
                something_changed = True

            if something_changed == True:
                debounce_timer = time.time()

def shift_out():
#    print('shift out started')
    # clear everything before we're about to start shifting
#    print(led)
    GPIO.output(SHIFT_LATCH_PIN, 0)
    GPIO.output(SHIFT_DATA_PIN, 0)
    
    # set clock to low, so the next transition is a rise
    GPIO.output(SHIFT_CLK_PIN, 0)
    
    for i in range(nLEDs):
        
        # set data to write
        GPIO.output(SHIFT_DATA_PIN, led[nLEDs-1-i])
        
        # on rising clock edge, data shifts one position
        GPIO.output(SHIFT_CLK_PIN, 1)

        # rpi clock is too fast, so delay to decrease frequency
        time.sleep(0.001)

        # reset clock
        GPIO.output(SHIFT_CLK_PIN, 0)


def display_leds():
#    print('display leds started')
    # setting this pin high attaches the output to the register's internal storage
    GPIO.output(SHIFT_LATCH_PIN, 1)

def save_board():
    print(led)
#    print('board save started')
    # open current_board.txt
    with open('current_board.txt','r') as current_board: # open current_board.txt
        file_lines = current_board.readlines() # this is a list. elements are lines of the file
        print(file_lines)
        while not file_lines: # if file lines is empty due to file change etc
            time.sleep(.050) # wait for 50 msec
            file_lines = current_board.readlines() # and check again
        diff = file_lines[5] # grab the difficulty label
        v = file_lines[6] # grab the difficulty index
    
    with open('current_board.txt','w') as current_board:  # reopen current_board.txt as a blank file
        for i in range(nLEDs):
            if (i != 0 and i % 8 == 0): current_board.write('\n') # write every 8 LEDs on a new line
            current_board.write(str(led[i])) 
        current_board.write('\n') # last new line before dumping difficulty
        current_board.write(diff) # reappend difficulty label
        current_board.write(v) # reappend difficulty index

def read_board():
#    print('read board started')
    index = 0 # led list iterator
    with open('current_board.txt','r') as current_board: # open current_board.txt
        file_lines = current_board.readlines() # this is a list. elements are lines of the file
        while not file_lines: # if file lines is empty due to file change etc
            time.sleep(.05) # wait for 50 msec
            file_lines = current_board.readlines() # and check again
#        print(file_lines)
        for line in range(5): # iterate over each line with led data. each line represents a column
#            print('line')
            digits = file_lines[line].strip('\n') # remove new line character from each line
#            print(digits)
            for char in range(8): # for each digit in the line
#                print(index)
#                print(digits[char])
#                print(digits[char])
                led[index] = int(digits[char]) # save the digit in the corresponding led list spot
                index = index + 1 # increment iterator so next digit is saved in the correct led list spot
#        print(led)

###################################################################################################
## MAIN LOOP

while True:
    time.sleep(.1)
    if (time.time() - timer > 0.2):
        periodic_refresh = True
    
    button_refresh();
    if (something_changed):
#        print('change status: '+str(something_changed))
        save_board()
        shift_out()
        display_leds()
        something_changed = False

    elif (periodic_refresh):
#        print('change status: '+str(something_changed))
        read_board()
        shift_out()
        display_leds()
        periodic_refresh = False
        timer = time.time()

    else: pass

GPIO.cleanup()